home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 September / Chip_2002-09_cd1.bin / sharewar / slunec / app / httrack.exe / {app} / src_win / WinHTTrack / newlang.cpp < prev    next >
C/C++ Source or Header  |  2002-01-20  |  13KB  |  472 lines
  1.  
  2. // Win includes
  3. #include "stdafx.h"
  4. #include "Shell.h"
  5.  
  6. // Hash for lang.h
  7. extern "C" {
  8.   #include "htshash.h"
  9. };
  10. #include "newlang.h"
  11.  
  12. // test
  13. #ifndef _MBCS
  14. #error "MBCS/DBCS support not found"
  15. #endif
  16. #include <locale.h>
  17.  
  18.  
  19. int NewLangStrSz=1024;
  20. inthash NewLangStr=NULL;
  21. int NewLangStrKeysSz=1024;
  22. inthash NewLangStrKeys=NULL;
  23.  
  24.  
  25. void LANG_LOAD(char* limit_to) {
  26.   CWaitCursor wait;
  27.   //
  28.   extern int NewLangStrSz;
  29.   extern inthash NewLangStr;
  30.   extern int NewLangStrKeysSz;
  31.   extern inthash NewLangStrKeys;
  32.   //
  33.   int selected_lang=LANG_T(-1);
  34.   //
  35.   if (!limit_to) {
  36.     LANG_DELETE();
  37.     NewLangStr=inthash_new(NewLangStrSz);
  38.     NewLangStrKeys=inthash_new(NewLangStrKeysSz);
  39.     if ((NewLangStr==NULL) || (NewLangStrKeys==NULL)) {
  40.       AfxMessageBox("Error in lang.h: not enough memory");
  41.     } else {
  42.       inthash_value_is_malloc(NewLangStr,1);
  43.       inthash_value_is_malloc(NewLangStrKeys,1);
  44.     }
  45.   }
  46.  
  47.   CString app;
  48.   CWinApp* pApp = AfxGetApp();
  49.   if (pApp) {
  50.     app=pApp->m_pszHelpFilePath;
  51.     app=app.Left(app.ReverseFind('\\')+1);
  52.   }
  53.  
  54.   /* Load master file (list of keys and internal keys) */
  55.   if (!limit_to) {
  56.     CString mname=app+"lang.def";
  57.     if (!fexist((char*)LPCTSTR(mname)))
  58.       mname="lang.def";
  59.     FILE* fp=fopen(mname,"rb");
  60.     if (fp) {
  61.       char intkey[8192];
  62.       char key[8192];
  63.       while(!feof(fp)) {
  64.         linput_cpp(fp,intkey,8000);
  65.         linput_cpp(fp,key,8000);
  66.         if (strnotempty(intkey) && strnotempty(key)) {
  67.           char* test=LANGINTKEY(key);
  68.  
  69.           /* Increment for multiple definitions */
  70.           if (strnotempty(test)) {
  71.             int increment=0;
  72.             int pos=strlen(key);
  73.             do {
  74.               increment++;
  75.               sprintf(key+pos,"%d",increment);
  76.               test=LANGINTKEY(key);
  77.             }  while (strnotempty(test));
  78.           }
  79.  
  80.           if (!strnotempty(test)) {         // Θviter doublons
  81.             // conv_printf(key,key);
  82.             int len;
  83.             char* buff;
  84.             len=strlen(intkey);
  85.             buff=(char*)malloc(len+2);
  86.             if (buff) {
  87.               strcpy(buff,intkey);
  88.               inthash_add(NewLangStrKeys,key,(long int)(char*)buff);
  89.             }
  90.           }
  91.         } // if
  92.       }  // while
  93.       fclose(fp);
  94.     } else {
  95.       AfxMessageBox("FATAL ERROR\r\n'lang.def' file NOT FOUND!\r\nEnsure that the installation was complete!");
  96.       exit(0);
  97.     }
  98.   }
  99.   
  100.   /* Language Name? */
  101.   char* hashname;
  102.   {
  103.     char name[256];
  104.     sprintf(name,"LANGUAGE_%d",selected_lang+1);
  105.     hashname=LANGINTKEY(name);
  106.   }
  107.  
  108.   /* Get only language name */
  109.   if (limit_to) {
  110.     if (hashname)
  111.       strcpy(limit_to,hashname);
  112.     else
  113.       strcpy(limit_to,"???");
  114.     return;
  115.   }
  116.  
  117.   /* Error */
  118.   if (!hashname)
  119.     return;
  120.  
  121.   // xxc TEST
  122.   /*
  123.   setlocale( LC_ALL, "Japanese");
  124.   _setmbcp(932);    // shift-jis
  125.   setlocale( LC_ALL, ".932" );
  126.   setlocale( LC_ALL, "[.932]" );
  127.   CString st="";
  128.   int lid=SetThreadLocale(MAKELCID(MAKELANGID(LANG_JAPANESE,SUBLANG_NEUTRAL),SORT_DEFAULT ));
  129.   */
  130.  
  131.   /* Load specific language file */
  132.   {
  133.     int loops;
  134.     CString err_msg="";
  135.     // 2nd loop: load undefined strings
  136.     for(loops=0;loops<2;loops++) {
  137.       CString lbasename;
  138.       
  139.       {
  140.         char name[256];
  141.         sprintf(name,"LANGUAGE_%d",(loops==0)?(selected_lang+1):1);
  142.         hashname=LANGINTKEY(name);
  143.       }
  144.       lbasename.Format("lang/%s.txt",hashname);
  145.       CString lname=app+lbasename;
  146.       if (!fexist((char*)LPCTSTR(lname)))
  147.         lname=lbasename;
  148.       FILE* fp=fopen(lname,"rb");
  149.       if (fp) {
  150.         char extkey[8192];
  151.         TCHAR value[8192];
  152.         while(!feof(fp)) {
  153.           //int ssz;
  154.           linput_cpp(fp,extkey,8000);
  155.           linput_cpp(fp,value,8000);
  156.           /*
  157.           ssz=linput_cpp(fp,value,8000);
  158.           CString st=value;
  159.           AfxMessageBox(st);
  160.           if (ssz>0) {
  161.             int tst=0;
  162.             int test=IsTextUnicode(value,ssz,&tst);
  163.             unsigned short st2[1024];
  164.             int ret=MultiByteToWideChar(CP_UTF8,0,(char*)value,ssz,st2,1024);
  165.             if (ret>0) {
  166.               char st3[1024]="";
  167.               int ret2=WideCharToMultiByte(CP_THREAD_ACP,0,st2,ret,(char*)st3,1024,NULL,FALSE);
  168.               if (ret2>0) {
  169.                 AfxMessageBox(st3);
  170.               }
  171.             }
  172.           }
  173.           */
  174.  
  175.           if (strnotempty(extkey) && strnotempty(value)) {
  176.             int len;
  177.             char* buff;
  178.             char* intkey;
  179.             
  180.             intkey=LANGINTKEY(extkey);
  181.             
  182.             if (strnotempty(intkey)) {
  183.               
  184.               /* Increment for multiple definitions */
  185.               {
  186.                 char* test=LANGSEL(intkey);
  187.                 if (strnotempty(test)) {
  188.                   if (loops == 0) {
  189.                     int increment=0;
  190.                     int pos=strlen(extkey);
  191.                     do {
  192.                       increment++;
  193.                       sprintf(extkey+pos,"%d",increment);
  194.                       intkey=LANGINTKEY(extkey);
  195.                       if (strnotempty(intkey))
  196.                         test=LANGSEL(intkey);
  197.                       else
  198.                         test="";
  199.                     }  while (strnotempty(test));
  200.                   } else
  201.                     intkey="";
  202.                 } else {
  203.                   if (loops > 0) {
  204.                     err_msg += intkey;
  205.                     err_msg += " ";
  206.                   }
  207.                 }
  208.               }
  209.               
  210.               /* Add key */
  211.               if (strnotempty(intkey)) {
  212.                 len=strlen(value);
  213.                 buff=(char*)malloc(len+2);
  214.                 if (buff) {
  215.                   conv_printf(value,buff);
  216.                   inthash_add(NewLangStr,intkey,(long int)(char*)buff);
  217.                 }
  218.               }
  219.               
  220.             }
  221.           } // if
  222.         }  // while
  223.         fclose(fp);
  224.       } else {
  225.         AfxMessageBox("FATAL ERROR\r\n'lang.def' file NOT FOUND!\r\nEnsure that the installation was complete!");
  226.         exit(0);
  227.       }
  228.     }
  229.     if (err_msg.GetLength()>0) {
  230.       // AfxMessageBox("Error: undefined strings follows:\r\n"+err_msg);
  231.     }
  232.   }
  233.  
  234.  
  235.  
  236. #if 0
  237.   app=app+"lang.h";
  238.   if (!fexist((char*)LPCTSTR(app)))
  239.     app="lang.h";
  240.   
  241.   FILE* fp=fopen(app,"rb");
  242.   if (fp) {
  243.     char s[8192];
  244.     while(!feof(fp)) {
  245.       linput_cpp(fp,s,8000);
  246.       if (!strncmp(s,"#define ",8)) {
  247.         char* a;
  248.         char* name=s+8;
  249.         a=name;
  250.         while((*a!=' ') && (*a)) a++;
  251.         if ((*a) && (strlen(name)>0) && (((int) a - (int) name)<64)) {
  252.           *a++='\0';
  253.           if (limit_to) {
  254.             if (strcmp(name,limit_to))
  255.               a=NULL;
  256.           }
  257.           if (a) {
  258.             char* data;
  259.             data=a;
  260.             int toggle=0;
  261.             char* start_str=NULL;
  262.             int count=0;
  263.             while(*a) {
  264.               if (*a=='\"') {
  265.                 toggle++;
  266.                 if ((toggle%2)==1) {
  267.                   if (count==selected_lang) {
  268.                     start_str=a+1;
  269.                   }
  270.                   count++;
  271.                 } else {
  272.                   if (start_str) {
  273.                     char* buff;
  274.                     int len;
  275.                     len=(int) a - (int) start_str;
  276.                     if (len) {
  277.                       buff=(char*)malloc(len+2);
  278.                       if (buff) {
  279.                         int i=0,j=0;
  280.                         buff[0]='\0';
  281.                         //strncat(buff,start_str,len);
  282.                         while(i<len) {
  283.                           switch(start_str[i]) {
  284.                           case '\\': 
  285.                             i++;
  286.                             switch(start_str[i]) {
  287.                             case 'a': buff[j]='\a'; break;
  288.                             case 'b': buff[j]='\b'; break;
  289.                             case 'f': buff[j]='\f'; break;
  290.                             case 'n': buff[j]='\n'; break;
  291.                             case 'r': buff[j]='\r'; break;
  292.                             case 't': buff[j]='\t'; break;
  293.                             case 'v': buff[j]='\v'; break;
  294.                             case '\'': buff[j]='\''; break;
  295.                             case '\"': buff[j]='\"'; break;
  296.                             case '\\': buff[j]='\\'; break;
  297.                             case '?': buff[j]='\?'; break;
  298.                             default: buff[j]=start_str[i]; break;
  299.                             }
  300.                             break;
  301.                             default: 
  302.                               buff[j]=start_str[i]; 
  303.                               break;
  304.                           }
  305.                           i++;
  306.                           j++;
  307.                         }
  308.                         buff[j++]='\0';
  309.                         if (!limit_to)
  310.                           inthash_add(NewLangStr,name,(long int)(char*)buff);
  311.                         else {
  312.                           strcpy(limit_to,buff);
  313.                           free(buff);
  314.                           return;
  315.                         }
  316.                       }
  317.                     }
  318.                     start_str=NULL;
  319.                   }
  320.                 }
  321.               }
  322.               a++;
  323.             }
  324.           }
  325.           
  326.           //NewLangStr.SetAt(sname,st);
  327.           /*
  328.           } else {
  329.           CString info;
  330.           info.Format("Error in lang.h: %s",name);
  331.           AfxMessageBox(info);
  332.         */
  333.         }
  334.       }
  335.     }
  336.  
  337.  
  338.     fclose(fp);
  339.  
  340.   } else {
  341.     AfxMessageBox("FATAL ERROR\r\n'lang.h' file NOT FOUND!\r\nEnsure that the installation was complete!");
  342.     exit(0);
  343.   }
  344. #endif
  345.  
  346.   // Control limit_to
  347.   if (limit_to)
  348.     limit_to[0]='\0';
  349. }
  350.  
  351. void conv_printf(char* from,char* to) {
  352.   int i=0,j=0,len;
  353.   len=strlen(from);
  354.   while(i<len) {
  355.     switch(from[i]) {
  356.     case '\\': 
  357.       i++;
  358.       switch(from[i]) {
  359.       case 'a': to[j]='\a'; break;
  360.       case 'b': to[j]='\b'; break;
  361.       case 'f': to[j]='\f'; break;
  362.       case 'n': to[j]='\n'; break;
  363.       case 'r': to[j]='\r'; break;
  364.       case 't': to[j]='\t'; break;
  365.       case 'v': to[j]='\v'; break;
  366.       case '\'': to[j]='\''; break;
  367.       case '\"': to[j]='\"'; break;
  368.       case '\\': to[j]='\\'; break;
  369.       case '?': to[j]='\?'; break;
  370.       default: to[j]=from[i]; break;
  371.       }
  372.       break;
  373.       default: 
  374.         to[j]=from[i]; 
  375.         break;
  376.     }
  377.     i++;
  378.     j++;
  379.   }
  380.   to[j++]='\0';
  381. }
  382.  
  383. void LANG_DELETE() {
  384.   extern int NewLangStrSz;
  385.   extern inthash NewLangStr;
  386.   extern int NewLangStrKeysSz;
  387.   extern inthash NewLangStrKeys;
  388.   //
  389.   inthash_delete(&NewLangStr);
  390.   inthash_delete(&NewLangStrKeys);
  391. }
  392.  
  393. // sΘlection de la langue
  394. void LANG_INIT() {
  395.   CWinApp* pApp = AfxGetApp();
  396.   if (pApp) {
  397.     int test = pApp->GetProfileInt("Language","IntId",0);
  398.     LANG_T(pApp->GetProfileInt("Language","IntId",0));
  399.   }
  400. }
  401.  
  402. int LANG_T(int l) {
  403.   if (l>=0) {
  404.     QLANG_T(l);
  405.     CWinApp* pApp = AfxGetApp();
  406.     if (pApp)
  407.       pApp->WriteProfileInt("Language","IntId",l);
  408.     LANG_LOAD(NULL);
  409.   }
  410.   return QLANG_T(-1);  // 0=default (english)
  411. }
  412.  
  413. int QLANG_T(int l) {
  414.   static int lng=0;
  415.   if (l>=0) {
  416.     lng=l;
  417.   }
  418.   return lng;  // 0=default (english)
  419. }
  420.  
  421.  
  422. /*
  423. char* LANGSEL(char* lang0,...) {
  424.   char* lang=lang0;
  425.   char* langalt="";
  426.   int langid=LANG_T(-1);
  427.   //
  428.   va_list argList;
  429.     va_start(argList, lang0);
  430.   while(langid>0) {
  431.     if (lang) {
  432.       if (strlen(langalt)==0) {
  433.         if (strlen(lang)>0)
  434.           langalt=lang;
  435.       }
  436.     }
  437.     langid--;
  438.     lang=va_arg(argList, char*);
  439.   }
  440.   va_end(argList);
  441.   //
  442.   if (!lang)
  443.     return langalt;
  444.   if (strlen(lang)==0)
  445.     return langalt;
  446.   return lang;
  447. }
  448. */
  449.  
  450. char* LANGSEL(char* name) {
  451.   unsigned long int adr=NULL;
  452.   if (NewLangStr)
  453.   if (!inthash_read(NewLangStr,name,(long int *)&adr))
  454.     adr=NULL;
  455.   if (adr) {
  456.     return (char*)adr;
  457.   }
  458.   return "";
  459. }
  460.  
  461. char* LANGINTKEY(char* name) {
  462.   unsigned long int adr=NULL;
  463.   if (NewLangStrKeys)
  464.   if (!inthash_read(NewLangStrKeys,name,(long int *)&adr))
  465.     adr=NULL;
  466.   if (adr) {
  467.     return (char*)adr;
  468.   }
  469.   return "";
  470. }
  471.  
  472.